MSG

# 6. 流程控制

# 流程控制

流程控制是每种编程语言控制逻辑走向和执行次序的重要部分，流程控制可以说是一门语言的“经脉”。

Go语言中最常用的流程控制有if和for，而switch和goto主要是为了简化代码、降低重复代码而生的结构，属于扩展类的流程控制。

在程序中，程序运行的流程控制决定程序是如何执行的，是我们必须掌握的，主要有三大流程控制语句

  1. 顺序控制
  2. 分支控制
  3. 循环控制

# 顺序控制

程序从上到下逐行地执行，中间没有任何判断和跳转

image-20200814180550269

必须下面的代码中，没有判断，也没有跳转.因此程序按照默认的流程执行，即顺序控制

image-20200814180541104

# 顺序控制举例和注意事项

//Golang 中定义变量时采用合法的前向引用。如：
func main() {
    var num1 int = 10 //声明了 num1
    var num2 int = num1 + 20 //使用 num1
    fmt.Println(num2)
}

//错误形式：
func main() {
    var num2 int = num1 + 20 //使用 num1
    var num1 int = 10 //声明 num1 (×)
    fmt.Println(num2)
}

# if 分支控制

if 表达式1 {
    分支1
} else if 表达式2 {
    分支2
} else{
    分支3
}

当表达式1的结果为true时，执行分支1，否则判断表达式2，如果满足则执行分支2，都不满足时，则执行分支3。 if判断中的else if和else都是可选的，可以根据实际需要进行选择。

Go语言规定与if匹配的左括号{必须与if和表达式放在同一行，{放在其他位置会触发编译错误。 同理，与else匹配的{也必须与else写在同一行，else也必须与上一个if或else if右边的大括号在同一行

如果出现多分支的情况下，比如上面代码，表达式1匹配成功后，执行完表达式1中的代码块后会自动跳出if判断，就算表达式2也能匹配成功，但是也不会走到表达式2，if判断默认匹配完条件后，执行匹配条件的代码块，自动退出if判断

举例

func ifDemo1() {
	score := 65
	if score >= 90 {
		fmt.Println("A")
	} else if score > 75 {
		fmt.Println("B")
	} else {
		fmt.Println("C")
	}
}
  1. 多分支的判断流程如下:
    1. 先判断条件表达式 1 是否成立，如果为真，就执行代码块 1
    2. 如果条件表达式 1 如果为假，就去判断条件表达式 2 是否成立， 如果条件表达式 2 为真，就执行代码块 2
    3. 依次类推.
    4. 如果所有的条件表达式不成立，则执行 else 的语句块。
  2. else 不是必须的。
  3. 多分支只能有一个执行入口。

# if条件判断特殊写法

if条件判断还有一种特殊的写法，可以在 if 表达式之前添加一个执行语句，再根据变量值进行判断，举个例子：

func ifDemo2() {
	if score := 65; score >= 90 {
		fmt.Println("A")
	} else if score > 75 {
		fmt.Println("B")
	} else {
		fmt.Println("C")
	}
}

把变量写入if判断中，一般不会这么做，因为这么做等于告诉系统，我这个变量只在if判断中使用，在if判断外都不能使用这个变量

# switch 分支控制

  1. switch 语句用于基于不同条件执行不同动作，每一个 case 分支都是唯一的，从上到下逐一测试，直到匹配为止
  2. 匹配项后面也 不需要再加 break

image-20200831103709754

  1. switch 的执行的流程是，先执行表达式，得到值，然后和 case 的表达式进行比较，如果相等，就匹配到，然后执行对应的 case 的语句块，然后退出 switch 控制。
  2. 如果 switch 的表达式的值没有和任何的 case 的表达式匹配成功，则执行 default 的语句块。执行后退出 switch 的控制.
  3. golang 的 case 后的表达式可以有多个，使用 逗号 间隔。
  4. golang 中的 case 语句块不需要写 break , 因为默认会有,即在默认情况下，当程序执行完 case 语句块后，就直接退出该 switch 控制结构。

使用switch语句可方便地对大量的值进行条件判断。

Go语言规定每个switch只能有一个default分支。

func switchDemo1() {
	finger := 3
	switch finger {
	case 1:
		fmt.Println("大拇指")
	case 2:
		fmt.Println("食指")
	case 3:
		fmt.Println("中指")
	case 4:
		fmt.Println("无名指")
	case 5:
		fmt.Println("小拇指")
	default:
		fmt.Println("无效的输入！")
	}
}

// 结果：
//   中指

一个分支可以有多个值，多个case值中间使用英文逗号分隔。

func testSwitch3() {
	switch n := 7; n {
	case 1, 3, 5, 7, 9:
		fmt.Println("奇数")
	case 2, 4, 6, 8:
		fmt.Println("偶数")
	default:
		fmt.Println(n)
	}
}
// 结果：
//   奇数

分支还可以使用表达式，这时候switch语句后面不需要再跟判断变量

func switchDemo4() {
	age := 30
	switch {
	case age < 25:
		fmt.Println("好好学习吧")
	case age > 25 && age < 35:
		fmt.Println("好好工作吧")
	case age > 60:
		fmt.Println("好好享受吧")
	default:
		fmt.Println("活着真好")
	}
}

// 结果：
//   好好工作吧

# fallthrough语法

fallthrough语法可以执行满足条件的case的下一个case，是为了兼容C语言中的case设计的。

func switchDemo5() {
	s := "a"
	switch {
	case s == "a":
		fmt.Println("a")
		fallthrough
	case s == "b":
		fmt.Println("b")
	case s == "c":
		fmt.Println("c")
	default:
		fmt.Println("...")
	}
}

// 结果：
//   a
//   b

# switch 的使用的注意事项和细节

  1. case/switch 后是一个表达式 ( 即： 常量值、变量、一个有 返回值的函数等都可以)

  2. case 后的各个表达式的值的数据类型，必须和 switch 的表达式数据类型一致

  3. case 后面可以带多个表达式，使用逗号间隔。比如 case 表达式 1, 表达式 2 ...

  4. case 后面的表达式如果是常量值(字面量)，则要求不能重复

  5. case 后面不需要带 break , 程序匹配到一个 case 后就会执行对应的代码块，然后退出 switch，如果一个都匹配不到，则执行 default

  6. default 语句不是必须的。

  7. switch 后也可以不带表达式，类似 if --else 分支来使用

  8. switch 后也可以直接声明/定义一个变量，分号结束， 不推荐

  9. switch 穿透-fallthrough ，如果在 case 语句块后增加 fallthrough ,则会继续执行下一个 case，也叫 switch 穿透

  10. Type Switch：switch 语句还可以被用于 type-switch 来判断某个 interface 变量中实际指向的变量类型

# switch 和 if 的比较

总结了什么情况下使用 switch ,什么情况下使用 if

  1. 如果判断的 具体数值不多，而且符合整数、浮点数、字符、字符串这几种类型。建议使用 swtich语句，简洁高效。
  2. 其他情况：对 区间判断和结果为 bool 类型的判断，使用 if，if 的使用范围更广。

# for 循环控制

听其名而知其意。就是让我们的一段代码循环的执行

Go 语言中的所有循环类型均可以使用for关键字来完成。

for 循环变量初始化; 循环条件; 循环变量迭代 {
	循环操作(语句)
}

1. 对 for 循环来说，有四个要素：
2. 循环变量初始化
3. 循环条件
4. 循环操作(语句) ,有人也叫循环体。
5. 循环变量迭代

for 循环执行的顺序:

  1. 执行循环变量初始化，比如 i := 1
  2. 执行循环条件， 比如 i <= 10
  3. 如果循环条件为真，就执行循环操作 :比如 fmt.Println(“....”)
  4. 执行循环变量迭代 , 比如 i++
  5. 反复执行 2, 3, 4 步骤，直到 循环条件为 False ，就退出 for 循环。

条件表达式返回true时循环体不停地进行循环，直到条件表达式返回false时自动退出循环。

func forDemo() {
	for i := 0; i < 10; i++ {
		fmt.Println(i)
	}
}

for循环的初始语句可以被忽略，但是初始语句后的分号必须要写

func forDemo2() {
	i := 0
	for ; i < 10; i++ {
		fmt.Println(i)
	}
}

for循环的初始语句和结束语句都可以省略，例如：

func forDemo3() {
	i := 0
	for i < 10 {
		fmt.Println(i)
		i++
	}
}

这种写法类似于其他编程语言中的while，比如python的while，在while后添加一个条件表达式，满足条件表达式时持续循环，否则结束循环。

# 无限循环

for循环可以通过break、goto、return、panic语句强制退出循环

for {
    循环体语句
}

# for range(键值循环)

Go语言中可以使用for range遍历数组、切片、字符串、map 及通道（channel）。 通过for range遍历的返回值有以下规律：

  1. 数组、切片、字符串返回索引和值。
  2. map返回键和值。
  3. 通道（channel）只返回通道内的值。
for key, value := range []int{1, 2, 3, 4} {
    fmt.Printf("key:%d  value:%d\n", key, value)
}

结果：
key:0  value:1
key:1  value:2
key:2  value:3
key:3  value:4

# for 循环的使用注意事项和细节

  1. 循环条件是返回一个 布尔值的表达式

  2. for 循环的第二种使用方式

    for 循环判断条件 {
	//循环执行语句
}
// 将变量初始化和变量迭代写到其它位置

  3. for 循环的第三种使用方式

for {
	//循环执行语句
}
上面的写法价 等价 for ; ; {} 是一个 无限循环， 通常需要 配合 break 语句使用

  1. Golang 提供 for-range 的方式，可以方便遍历字符串和数组

  2. 字符串遍历方式 1-传统方式

  3. 字符串遍历方式 2-for - range

  4. 如果我们的字符串含有中文，那么传统的遍历字符串方式，就是错误，会出现乱码。原因是传统的对字符串的遍历是按照 字节来遍历，而一个汉字在 utf8 编码是对应 3 个字节。

    1. 对传统方式 需要要将 str 转成 []rune 切片
    2. 对应 for-range 遍历方式而言，是按照字符方式遍历。因此如果有字符串有中文，也是 okimage-20200831110005314

# 多重循环控制(重点，难点)

  1. 将一个循环放在另一个循环体内，就形成了嵌套循环。在外边的 for 称为外层循环在里面的 for循环称为内层循环。【 建议一般使用两层，最多不要超过 3 层】
  2. 实质上，嵌套循环就是把内层循环当成外层循环的循环体。当只有内层循环的循环条件为 false时，才会完全跳出内层循环，才可结束外层的当次循环，开始下一次的循环。
  3. 外层循环次数为 m 次，内层为 n 次，则内层循环体实际上需要执行 m*n 次

# 跳转控制语句-break

break语句可以结束for、switch和select的代码块。

break语句还可以在语句后面添加标签，表示退出某个标签对应的代码块，标签要求必须定义在对应的for、switch和 select的代码块上。 举个例子：

{ ……
break
……
}

举例

func breakDemo1() {
BREAKDEMO1:
	for i := 0; i < 10; i++ {
		for j := 0; j < 10; j++ {
			if j == 2 {
				break BREAKDEMO1
			}
			fmt.Printf("%v-%v\n", i, j)
		}
	}
	fmt.Println("...")
}

# 跳转控制语句-continue

  1. continue 语句用于 结束本次循环，继续 执行下一次循环
  2. continue 语句出现在多层嵌套的循环语句体中时，环 可以通过标签指明要跳过的是哪一层循环 , 这个和前面的 break 标签的使用的规则一样.
{ ……
continue
……
}

举例

continue语句可以结束当前循环，开始下一次的循环迭代过程，仅限在for循环内使用。

在 continue语句后添加标签时，表示开始标签对应的循环。例如：

func continueDemo() {
forloop1:
	for i := 0; i < 5; i++ {
		// forloop2:
		for j := 0; j < 5; j++ {
			if i == 2 && j == 2 {
				continue forloop1
			}
			fmt.Printf("%v-%v\n", i, j)
		}
	}
}

# 跳转控制语句-goto （很少用，不多说）

  1. Go 语言的 goto 语句可以无条件地转移到程序中指定的行。
  2. goto 语句通常与条件语句配合使用。可用来实现条件转移，跳出循环体等功能。
  3. 在 Go 程序设计中 一般不主张使用 goto 语句， 以免造成程序流程的混乱，使理解和调试程序都产生困难
goto label
.. .
label: statement

← 7. 数组 →